<exampleAINetIterface>
	<inputSummary>
		Add 0 or more nodes. Change any numbers in any nodes (within certain limits).
		Run the network's main execute function, which may leave the network in a stable state or not.
		The main function does nothing if the network is in a stable state.
		Adding nodes or changing numbers usually puts the network in an unstable state.
		If the network state is stable or not is deterministic and the measure of that never changes.
	</inputSummary>
	
	/** When a Node is changed enough that the sorted order of this Net's Nodes would change,
	it is added to this Set and sorted later. Until then, the only way to know the
	first Node is to find the highest valued Node in this Set.
	When the other list/array of Nodes is sorted, this Set should be cleared and
	only the first few Nodes in that list/array added to this Set.
	When this Set gets too big, do that again.
	This Set must always contain the highest scoring Node,
	so if the highest scoring 20 Nodes are put in this Set after every sort,
	this Set can be used at most 20 times before the next sort,
	but that is not enough because all Nodes in this Set may quickly start scoring low
	which would require the 21st Node be brought into this Set
	therefore a minimum score must be kept and if all Nodes in this Set score below it
	then a new sort must be done.
	*/
	public Set<Node> possiblyActiveNodes;
	
	/** Before each cycle of the Net, if all Nodes in the possiblyActiveNodes Set score below this,
	a higher scoring Node must be put in that Set. An easy way to do that is to do the whole sorting.
	When updating nodes (like firing 1 Node in a neural network and updating its childs too),
	Nodes with scores at least this high must be put in the Set, but putting other Nodes in the Set is optional.
	Low scoring Nodes are allowed in the Set because their score may decrease while they're in the Set.
	*/
	public double minActiveScore;
	
	/** minimum possible node.childs().size() */
	public int nodeChildsSizeMin;

	/** maximum possible node.childs().size() */
	public int nodeChildsSizeMax;
	
	/** action of this Net (Net extends Node). TODO: can this be standardized and removed from this class? */
	public fNoder netAction;
	
	/** TODO: How does the fNoder know and use theNode.childs().size()? */
	public fNoder nodeAction;

	/** returns a function that can be used to add a Node to this Net,
	and that should not be done any other way.
	*/
	public fNode2r nodeAdd;

	/** returns a function that can be used to remove a Node from this Net,
	and that should not be done any other way.
	*/
	public fNode2r nodeDelete;
	
	//TODO: may need a fNode3r because some of these fNode2r need this Net to be a parameter.
	//For example, when adding a Node as a child of a Node, this Net needs to add it to the list of Nodes if it wasnt there. 

	/** fNode2r(x,y) adds y to the end of x's child list.
	Because nodes are defined as symmetric between all childs,
	adding at the end has the same effect as adding at any other index.
	*/ 
	public fNode3r nodeChildAdd;

	/** Function that deletes a child node from another node */
	public fNode3r nodeChildDelete;
	
</exampleAINetIterface>